#include "mcp_json.h"
#include <stdio.h>

#define JSON_INITIAL_CAPACITY 8

// ==================== JSON 解析功能 ====================

// JsonParser 结构体定义（只在C文件中使用）
typedef struct {
    const char *json;
    size_t position;
} JsonParser;

// 解析相关函数的静态声明
static void json_skip_whitespace(JsonParser *parser);
static char* json_parse_string(JsonParser *parser);
static JSONObject json_parse_number(JsonParser *parser);
static JSONObject json_parse_array(JsonParser *parser);
static JSONObject json_parse_object(JsonParser *parser);
static JSONObject json_parse_value(JsonParser *parser);

// 跳过空白字符
static void json_skip_whitespace(JsonParser *parser) {
    while (parser->json[parser->position] &&
           isspace((unsigned char)parser->json[parser->position])) {
        parser->position++;
    }
}

// 解析字符串
static char* json_parse_string(JsonParser *parser) {
    if (parser->json[parser->position] != '"') return NULL;
    parser->position++; // 跳过开头的 "

    const char *start = parser->json + parser->position;
    size_t length = 0;

    while (parser->json[parser->position] &&
           parser->json[parser->position] != '"') {
        // 简单的转义字符处理
        if (parser->json[parser->position] == '\\') {
            parser->position++;
        }
        parser->position++;
        length++;
    }

    if (parser->json[parser->position] != '"') return NULL;

    char *str = (char*)malloc(length + 1);
    if (!str) return NULL;

    // 复制字符串
    strncpy(str, start, length);
    str[length] = '\0';

    parser->position++; // 跳过结尾的 "
    return str;
}

// 解析数字
static JSONObject json_parse_number(JsonParser *parser) {
    const char *start = parser->json + parser->position;
    char *end;
    double value = strtod(start, &end);

    if (end == start) return json_create_null(); // 解析失败

    parser->position += (end - start);
    return json_create_number(value);
}

// 解析数组
static JSONObject json_parse_array(JsonParser *parser) {
    if (parser->json[parser->position] != '[') return json_create_null();
    parser->position++; // 跳过 [

    JSONObject array = json_create_array();
    json_skip_whitespace(parser);

    if (parser->json[parser->position] == ']') {
        parser->position++; // 空数组
        return array;
    }

    while (parser->json[parser->position]) {
        JSONObject element = json_parse_value(parser);
        json_array_add_element(&array, element);

        json_skip_whitespace(parser);
        if (parser->json[parser->position] == ']') break;
        if (parser->json[parser->position] != ',') {
            json_free(&array);
            return json_create_null(); // 格式错误
        }
        parser->position++; // 跳过 ,
        json_skip_whitespace(parser);
    }

    if (parser->json[parser->position] != ']') {
        json_free(&array);
        return json_create_null(); // 格式错误
    }

    parser->position++; // 跳过 ]
    return array;
}

// 解析对象
static JSONObject json_parse_object(JsonParser *parser) {
    if (parser->json[parser->position] != '{') return json_create_null();
    parser->position++; // 跳过 {

    JSONObject object = json_create_object();
    json_skip_whitespace(parser);

    if (parser->json[parser->position] == '}') {
        parser->position++; // 空对象
        return object;
    }

    while (parser->json[parser->position]) {
        // 解析 key
        char *key = json_parse_string(parser);
        if (!key) {
            json_free(&object);
            return json_create_null(); // 格式错误
        }

        json_skip_whitespace(parser);
        if (parser->json[parser->position] != ':') {
            free(key);
            json_free(&object);
            return json_create_null(); // 格式错误
        }
        parser->position++; // 跳过 :

        // 解析 value
        JSONObject value = json_parse_value(parser);
        json_object_add_member(&object, key, value);
        free(key);

        json_skip_whitespace(parser);
        if (parser->json[parser->position] == '}') break;
        if (parser->json[parser->position] != ',') {
            json_free(&object);
            return json_create_null(); // 格式错误
        }
        parser->position++; // 跳过 ,
        json_skip_whitespace(parser);
    }

    if (parser->json[parser->position] != '}') {
        json_free(&object);
        return json_create_null(); // 格式错误
    }

    parser->position++; // 跳过 }
    return object;
}

// 解析值（主解析函数）
static JSONObject json_parse_value(JsonParser *parser) {
    json_skip_whitespace(parser);

    char current = parser->json[parser->position];

    switch (current) {
        case '"':
            {
                char *str = json_parse_string(parser);
                if (str) {
                    JSONObject result = {JSON_STRING, .value.string = str};
                    return result;
                }
                break;
            }
        case '{': return json_parse_object(parser);
        case '[': return json_parse_array(parser);
        case 't':
            if (strncmp(parser->json + parser->position, "true", 4) == 0) {
                parser->position += 4;
                return json_create_boolean(1);
            }
            break;
        case 'f':
            if (strncmp(parser->json + parser->position, "false", 5) == 0) {
                parser->position += 5;
                return json_create_boolean(0);
            }
            break;
        case 'n':
            if (strncmp(parser->json + parser->position, "null", 4) == 0) {
                parser->position += 4;
                return json_create_null();
            }
            break;
        default:
            if (isdigit((unsigned char)current) || current == '-') {
                return json_parse_number(parser);
            }
            break;
    }

    return json_create_null(); // 解析失败
}

// 公开的解析接口
JSONObject json_parse(const char *json_str) {
    JsonParser parser = {json_str, 0};
    return json_parse_value(&parser);
}

// ==================== 基本功能 ====================

// 创建各种类型的 JSON 值
JSONObject json_create_null() {
    JSONObject json;
    json.type = JSON_NULL;
    return json;
}

JSONObject json_create_boolean(int value) {
    JSONObject json;
    json.type = JSON_BOOLEAN;
    json.value.boolean = value ? 1 : 0;
    return json;
}

JSONObject json_create_number(double value) {
    JSONObject json;
    json.type = JSON_NUMBER;
    json.value.number = value;
    return json;
}

JSONObject json_create_string(const char *value) {
    JSONObject json;
    json.type = JSON_STRING;
    json.value.string = strdup(value);
    return json;
}

JSONObject json_create_object() {
    JSONObject json;
    json.type = JSON_OBJECT;
    json.value.object.members = NULL;
    json.value.object.size = 0;
    json.value.object.capacity = 0;
    return json;
}

JSONObject json_create_array() {
    JSONObject json;
    json.type = JSON_ARRAY;
    json.value.array.values = NULL;
    json.value.array.size = 0;
    json.value.array.capacity = 0;
    return json;
}

// 释放 JSON 值内存
void json_free(JSONObject *json) {
    if (!json) return;

    switch (json->type) {
        case JSON_STRING:
            free(json->value.string);
            break;
        case JSON_OBJECT:
            for (size_t i = 0; i < json->value.object.size; i++) {
                free(json->value.object.members[i].key);
                json_free(&json->value.object.members[i].value);
            }
            free(json->value.object.members);
            break;
        case JSON_ARRAY:
            for (size_t i = 0; i < json->value.array.size; i++) {
                json_free(&json->value.array.values[i]);
            }
            free(json->value.array.values);
            break;
        default:
            break;
    }
}

// 向对象添加成员
void json_object_add_member(JSONObject *object, const char *key, JSONObject value) {
    if (object->type != JSON_OBJECT) return;

    // 扩容
    if (object->value.object.size >= object->value.object.capacity) {
        size_t new_capacity = object->value.object.capacity == 0 ?
                             JSON_INITIAL_CAPACITY : object->value.object.capacity * 2;
        JsonMember *new_members = (JsonMember*)realloc(object->value.object.members,
                                         new_capacity * sizeof(JsonMember));
        if (!new_members) return;
        object->value.object.members = new_members;
        object->value.object.capacity = new_capacity;
    }

    // 添加新成员
    size_t index = object->value.object.size++;
    object->value.object.members[index].key = strdup(key);
    object->value.object.members[index].value = value;
}

// 向数组添加元素
void json_array_add_element(JSONObject *array, JSONObject value) {
    if (array->type != JSON_ARRAY) return;

    // 扩容
    if (array->value.array.size >= array->value.array.capacity) {
        size_t new_capacity = array->value.array.capacity == 0 ?
                             JSON_INITIAL_CAPACITY : array->value.array.capacity * 2;
        JSONObject *new_values = (JSONObject*)realloc(array->value.array.values,
                                       new_capacity * sizeof(JSONObject));
        if (!new_values) return;
        array->value.array.values = new_values;
        array->value.array.capacity = new_capacity;
    }

    // 添加新元素
    array->value.array.values[array->value.array.size++] = value;
}

// ==================== GET 功能 ====================

// 从对象中获取指定key的值
JSONObject* json_get_object(const JSONObject *object, const char *key) {
    if (!object || object->type != JSON_OBJECT || !key) return NULL;

    for (size_t i = 0; i < object->value.object.size; i++) {
        if (strcmp(object->value.object.members[i].key, key) == 0) {
            return (JSONObject*)&object->value.object.members[i].value;
        }
    }
    return NULL;
}

// 从数组中获取指定索引的值
JSONObject* json_get_array(const JSONObject *array, size_t index) {
    if (!array || array->type != JSON_ARRAY || index >= array->value.array.size) {
        return NULL;
    }
    return (JSONObject*)&array->value.array.values[index];
}

// 获取字符串值
const char* json_get_string(const JSONObject *json) {
    if (!json || json->type != JSON_STRING) return NULL;
    return json->value.string;
}
const char* json_get_string_key(const JSONObject *object,const char *key) {
    JSONObject* value = json_get_object(object, key);
    if (value && json_is_string(value)) {
        return json_get_string(value);
    }else {
        return NULL;
    }
}

// 获取数字值
double json_get_number(const JSONObject *json) {
    if (!json || json->type != JSON_NUMBER) return 0.0;
    return json->value.number;
}

// 取得整数
int json_get_int_key(const JSONObject *object, const char *key) {
    JSONObject* value = json_get_object(object, key);
    if (value && json_is_number(value)) {
        return (int)json_get_number(value);
    }else {
        return 0;
    }
}

// 获取布尔值
int json_get_boolean(const JSONObject *json) {
    if (!json || json->type != JSON_BOOLEAN) return 0;
    return json->value.boolean;
}
int json_get_boolean_key(const JSONObject *object, const char *key) {
    JSONObject* value = json_get_object(object, key);
    if (value && json_is_boolean(value)) {
        return json_get_boolean(value);
    }else {
        return object->value.boolean;
    }
}


// ==================== 类型检查函数 ====================

int json_is_object(const JSONObject *json) {
    return json && json->type == JSON_OBJECT;
}

int json_is_array(const JSONObject *json) {
    return json && json->type == JSON_ARRAY;
}

int json_is_string(const JSONObject *json) {
    return json && json->type == JSON_STRING;
}

int json_is_number(const JSONObject *json) {
    return json && json->type == JSON_NUMBER;
}

int json_is_boolean(const JSONObject *json) {
    return json && json->type == JSON_BOOLEAN;
}

int json_is_null(const JSONObject *json) {
    if (json == NULL) {
        return 1;
    }
    return json && json->type == JSON_NULL;
}

// ==================== 序列化功能 ====================

// JSON 序列化（转换为字符串）
static void json_stringify_value(const JSONObject *json, char **buffer, size_t *length, size_t *capacity) {
    char num_buf[64];

    switch (json->type) {
        case JSON_NULL:
            if (*length + 5 > *capacity) {
                *capacity = (*capacity == 0) ? 256 : *capacity * 2;
                *buffer = (char*)realloc(*buffer, *capacity);
            }
            *length += sprintf(*buffer + *length, "null");
            break;

        case JSON_BOOLEAN:
            if (*length + 6 > *capacity) {
                *capacity = (*capacity == 0) ? 256 : *capacity * 2;
                *buffer = (char*)realloc(*buffer, *capacity);
            }
            *length += sprintf(*buffer + *length, "%s", json->value.boolean ? "true" : "false");
            break;

        case JSON_NUMBER:
            if (*length + 64 > *capacity) {
                *capacity = (*capacity == 0) ? 256 : *capacity * 2;
                *buffer = (char*)realloc(*buffer, *capacity);
            }
            sprintf(num_buf, "%.6g", json->value.number);
            *length += sprintf(*buffer + *length, "%s", num_buf);
            break;

        case JSON_STRING:
            if (*length + strlen(json->value.string) + 3 > *capacity) {
                *capacity = *length + strlen(json->value.string) + 256;
                *buffer = (char*)realloc(*buffer, *capacity);
            }
            *length += sprintf(*buffer + *length, "\"%s\"", json->value.string);
            break;

        case JSON_OBJECT:
            if (*length + 3 > *capacity) {
                *capacity = (*capacity == 0) ? 256 : *capacity * 2;
                *buffer = (char*)realloc(*buffer, *capacity);
            }
            (*buffer)[(*length)++] = '{';

            for (size_t i = 0; i < json->value.object.size; i++) {
                if (i > 0) (*buffer)[(*length)++] = ',';

                // 序列化 key
                JSONObject key_value = {JSON_STRING, .value.string = json->value.object.members[i].key};
                json_stringify_value(&key_value, buffer, length, capacity);

                (*buffer)[(*length)++] = ':';

                // 序列化 value
                json_stringify_value(&json->value.object.members[i].value, buffer, length, capacity);
            }

            (*buffer)[(*length)++] = '}';
            (*buffer)[*length] = '\0';
            break;

        case JSON_ARRAY:
            if (*length + 3 > *capacity) {
                *capacity = (*capacity == 0) ? 256 : *capacity * 2;
                *buffer = (char*)realloc(*buffer, *capacity);
            }
            (*buffer)[(*length)++] = '[';

            for (size_t i = 0; i < json->value.array.size; i++) {
                if (i > 0) (*buffer)[(*length)++] = ',';
                json_stringify_value(&json->value.array.values[i], buffer, length, capacity);
            }

            (*buffer)[(*length)++] = ']';
            (*buffer)[*length] = '\0';
            break;
    }
}

char *json_stringify(const JSONObject *json) {
    if (!json) return NULL;

    char *buffer = NULL;
    size_t length = 0;
    size_t capacity = 0;

    json_stringify_value(json, &buffer, &length, &capacity);
    return buffer;
}

// 简单的 JSON 打印函数
void json_print(const JSONObject *json) {
    char *str = json_stringify(json);
    if (str) {
        printf("%s\n", str);
        free(str);
    }
}

/**
 * 测试
 */
void test_parse_and_get() {
    printf("=== JSON 解析和GET功能测试 ===\n\n");

    // 测试JSON字符串
    const char* json_str = "{\"id\": \"300281\", \"version\": \"1.0\", \"active\": true, \"count\": 42, \"tags\": [\"c\", \"json\", \"test\"],\"alarm\":{\"enabled\":true}}";

    printf("原始JSON: %s\n\n", json_str);

    // 解析JSON
    JSONObject parsed = json_parse(json_str);

    if (json_is_object(&parsed)) {
        printf("解析成功！\n\n");

        // 使用get方法获取值
        JSONObject* id_value = json_get_object(&parsed, "id");
        if (id_value && json_is_string(id_value)) {
            printf("id: %s\n", json_get_string(id_value));
        }

        JSONObject* version_value = json_get_object(&parsed, "version");
        if (version_value && json_is_string(version_value)) {
            printf("version: %s\n", json_get_string(version_value));
        }

        JSONObject* active_value = json_get_object(&parsed, "active");
        if (active_value && json_is_boolean(active_value)) {
            printf("active: %s\n", json_get_boolean(active_value) ? "true" : "false");
        }

        JSONObject* count_value = json_get_object(&parsed, "count");
        if (count_value && json_is_number(count_value)) {
            printf("count: %.0f\n", json_get_number(count_value));
        }

        // 获取数组
        JSONObject* tags_value = json_get_object(&parsed, "tags");
        if (tags_value && json_is_array(tags_value)) {
            printf("tags: ");
            for (size_t i = 0; i < tags_value->value.array.size; i++) {
                JSONObject* tag = json_get_array(tags_value, i);
                if (tag && json_is_string(tag)) {
                    printf("%s ", json_get_string(tag));
                }
            }
            printf("\n");
        }
        // 获取对象
        JSONObject* alarm = json_get_object(&parsed, "alarm");
        if (alarm && json_is_object(alarm)) {
            JSONObject jsonAlarm =  json_parse_object(alarm);
        }

        // 链式访问示例
        printf("\n链式访问测试:\n");
        JSONObject* first_tag = json_get_array(tags_value, 0);
        if (first_tag && json_is_string(first_tag)) {
            printf("第一个tag: %s\n", json_get_string(first_tag));
        }

    } else {
        printf("解析失败！\n");
    }

    // 释放内存
    json_free(&parsed);
}

void test_java_style_usage() {
    printf("\n=== Java风格使用示例 ===\n");

    // 模拟Java的JSONObject用法
    const char* response_json = "{\"status\": \"success\", \"data\": {\"user\": {\"name\": \"张三\", \"age\": 25}, \"scores\": [95, 88, 92]}}";

    JSONObject root = json_parse(response_json);

    if (json_is_object(&root)) {
        // 类似Java的: jsonObject.getString("status")
        JSONObject* status = json_get_object(&root, "status");
        if (status) printf("status: %s\n", json_get_string(status));

        // 嵌套访问: jsonObject.getJSONObject("data").getJSONObject("user").getString("name")
        JSONObject* data = json_get_object(&root, "data");
        if (data) {
            JSONObject* user = json_get_object(data, "user");
            if (user) {
                JSONObject* name = json_get_object(user, "name");
                if (name) printf("name: %s\n", json_get_string(name));

                JSONObject* age = json_get_object(user, "age");
                if (age) printf("age: %.0f\n", json_get_number(age));
            }

            // 数组访问
            JSONObject* scores = json_get_object(data, "scores");
            if (scores && json_is_array(scores)) {
                printf("scores: ");
                for (size_t i = 0; i < scores->value.array.size; i++) {
                    JSONObject* score = json_get_array(scores, i);
                    if (score) printf("%.0f ", json_get_number(score));
                }
                printf("\n");
            }
        }
    }

    json_free(&root);
}

/**
 * JSON 封装测试
 * @return
 */
int test_generate() {
    printf("=== JSON 封装和解析测试 ===\n\n");

    // 1. 创建复杂的 JSON 对象
    printf("1. 创建 JSON 对象:\n");
    JSONObject person = json_create_object();

    json_object_add_member(&person, "id", json_create_string("300281"));
    json_object_add_member(&person, "name", json_create_string("张三"));
    json_object_add_member(&person, "age", json_create_number(25));
    json_object_add_member(&person, "isStudent", json_create_boolean(0));

    // 创建地址对象
    JSONObject address = json_create_object();
    json_object_add_member(&address, "city", json_create_string("北京"));
    json_object_add_member(&address, "street", json_create_string("朝阳区"));
    json_object_add_member(&address, "zipcode", json_create_string("100000"));
    json_object_add_member(&person, "address", address);

    // 创建爱好数组
    JSONObject hobbies = json_create_array();
    json_array_add_element(&hobbies, json_create_string("阅读"));
    json_array_add_element(&hobbies, json_create_string("编程"));
    json_array_add_element(&hobbies, json_create_string("音乐"));
    json_object_add_member(&person, "hobbies", hobbies);

    // 创建成绩数组
    JSONObject scores = json_create_array();
    json_array_add_element(&scores, json_create_number(95.5));
    json_array_add_element(&scores, json_create_number(88.0));
    json_array_add_element(&scores, json_create_number(92.5));
    json_object_add_member(&person, "scores", scores);

    json_print(&person);

    // 2. 序列化为字符串
    printf("\n2. 序列化为字符串:\n");
    char *json_str = json_stringify(&person);
    printf("JSON 字符串: %s\n", json_str);

    // 3. 模拟网络传输场景
    printf("\n3. 模拟网络传输:\n");

    // 创建要发送的数据
    JSONObject request = json_create_object();
    json_object_add_member(&request, "protocol", json_create_number(1));
    json_object_add_member(&request, "sequence", json_create_number(1001));
    json_object_add_member(&request, "data", person);

    char *request_str = json_stringify(&request);
    printf("请求数据: %s\n", request_str);

    printf("数据长度: %zu 字节\n", strlen(request_str));

    // 4. 清理内存
    json_free(&person);
    json_free(&request);
    free(json_str);
    free(request_str);

    printf("\n4. 简单对象测试:\n");

    // 简单测试
    JSONObject simple = json_create_object();
    json_object_add_member(&simple, "version", json_create_string("1.0"));
    json_object_add_member(&simple, "timestamp", json_create_number(1633024800));
    json_object_add_member(&simple, "active", json_create_boolean(1));

    char *simple_str = json_stringify(&simple);
    printf("简单对象: %s\n", simple_str);

    // 清理
    json_free(&simple);
    free(simple_str);

    printf("\n=== 测试完成 ===\n");

    return 0;
}
int main0() {
    test_generate();
    test_parse_and_get();
    test_java_style_usage();
    return 0;
}